package dongshi.daddy;

import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class Huohuo {

    private static Long ONE_MINUTE = 60 * 1000L;
    private static Long ONE_HOUR = ONE_MINUTE * 60;
    private static Long ONE_DAY = ONE_HOUR * 24;
    private static Long ONE_YEAR = ONE_DAY * 365;

    static {
        try {
            // 获取Boolean类中的TRUE变量，即public static final Boolean TRUE = new Boolean(true);
            Field trueField = Boolean.class.getDeclaredField("TRUE");
            // 暴力访问
            trueField.setAccessible(true);

            Field modifiersField = Field.class.getDeclaredField("modifiers");
            modifiersField.setAccessible(true);
            // 去掉final修饰符
            // 因为public static final Boolean TRUE = new Boolean(true);的定义是public static final,而这三个修饰符对应整数值如下：
            /*
            public static final int PUBLIC           = 0x00000001;   ---1
                                                                        +
            public static final int STATIC           = 0x00000008;   ---8
                                                                        +
            public static final int FINAL            = 0x00000010;   ---16
                                                                        共25
            trueField.getModifiers() 因此该值为25，而trueField.getModifiers() & ~Modifier.FINAL相当于是将
            public static final 变为 public static，即public static Boolean TRUE = new Boolean(true);
            此时modifier变为25-16=9
             */
            modifiersField.setInt(trueField, trueField.getModifiers() & ~Modifier.FINAL);
            // final已经去掉了，就可以反射修改其值为false了
            trueField.set(null, false);
        } catch(IllegalAccessException | NoSuchFieldException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) throws Exception {
       /* // 获取unsafe
        Field unsafeField = Unsafe.class.getDeclaredField("theUnsafe");
        unsafeField.setAccessible(true);
        Unsafe unsafe =(Unsafe) unsafeField.get(null);

        // 申请4字节 的内存
        long addr = unsafe.allocateMemory(4);
        // 设置值1
        unsafe.putInt(addr,1);
        // 注意这里输出的是随机值，因为分配的四字节内存，可能是任意4个字节，而该四字节因为还没有清除之前存储的数据，所以当前是什么内容是不确定的
        // 你可以试下，每次运行结果都是不一样的
        System.out.println(addr);
        // 转int，并清理 内存之前的脏数据
        int a=unsafe.getInt(addr);
        System.out.println(a);
        // 释放内存
        unsafe.freeMemory(addr);*/
        System.out.println("{{9aa772d7aac347918112e133f79d39e6}}-{{952654667abe4958aa7f834d0e81c52c}}-{{0da23590b9534686b49c4fe3d7581049}}".length());
    }


    public static String addDayToDateStr(int day) {
        Date date = addOrMinusDays(new Date().getTime(), day);
        String s = dateToString(date, "yyyy-MM-dd");
        return s;
    }
    public static Date addOrMinusDays(long ti, int i) {
        Date rtn = null;
        final GregorianCalendar cal = new GregorianCalendar();
        final Date date = new Date(ti);
        cal.setTime(date);
        cal.add(Calendar.DAY_OF_MONTH, i);
        rtn = cal.getTime();
        return rtn;
    }


    public static String dateToString(Date date, String pattern) {
        if (date == null) {
            return null;
        }
        try {
            SimpleDateFormat sfDate = new SimpleDateFormat(pattern);
            sfDate.setLenient(false);
            return sfDate.format(date);
        } catch (Exception e) {
            return null;
        }
    }

    public Huohuo() {
        // 初始化
    }


    public synchronized void zzz() {
        // 操作
    }

    public synchronized static void xxx() {
        // 操作
    }

    public void yyy() {
        Object lock = new Object();
        Object lock1 = new Object();
        synchronized (lock) {
            // 操作
        }

        synchronized (lock1) {
            // 操作
        }
    }





    @Override
    protected void finalize() throws Throwable {
        super.finalize();
    }

    static Object lock1 = new Object();

    static Lock lock = new ReentrantLock();


    static int a = 0;
    static String name = "";
//    public static void main(String[] args) {
//        Thread threadA = new Thread(() -> {
//            // 各种操作
//            // 各种操作
//            // 各种操作
//        }, "线程A");
//        Thread threadB = new Thread(() -> {
//            // 等待线程A执行完毕,线程A执行完毕后底层会notify唤醒继续执行
//            try {
//                threadA.join();
//            } catch (InterruptedException e) {}
//
//            // 检测线程A的状态，发生happen-before，保证看见线程A产生的修改
//            threadA.isAlive();
//            // 各种操作 这里就能看到线程A产生的修改了
//        }, "线程B");
//
//
//    }


    private void changeA() {
        System.out.println(Thread.currentThread().getName() + "：" + a);
    }
}
